package juc.blockqueue.aynchronousqueue;

/**
 * @ClassName SynchronousQueue
 * @PackageName juc.blockqueue.aynchronousqueue
 * @projectName myThread
 * @Description TODO
 * @Author games
 * @Date 2025/9/4 下午1:38
 * @Version 1.0
 */

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;

/**
 * SynchronousQueue 使用详解
 * SynchronousQueue 是一个特殊的阻塞队列，它没有内部容量，每个插入操作必须等待对应的移除操作，反之亦然。它更像是一个数据传递的通道而非传统意义上的队列。
 * 基本特性
 * 零容量：理论容量为0，不能存储元素
 * 直接传递：生产者线程直接将元素传递给消费者线程
 * 阻塞特性：
 * 当没有消费者等待时，生产者插入操作会阻塞
 * 当没有生产者等待时，消费者获取操作会阻塞
 * 线程配对：生产者和消费者线程必须配对才能完成数据传递
 * 公平性：支持公平和非公平模式（默认非公平）
 *
 *
 *
 * 主要方法
 * 插入操作
 * put(E e)：插入元素，没有等待的消费者时会阻塞
 * offer(E e)：尝试插入元素，立即返回 true/false
 * offer(E e, long timeout, TimeUnit unit)：尝试插入元素，可设置超时时间
 * 移除操作
 * take()：获取元素，没有等待的生产者时会阻塞
 * poll()：尝试获取元素，立即返回元素或 null
 * poll(long timeout, TimeUnit unit)：尝试获取元素，可设置超时时间
 * 工作原理
 * SynchronousQueue 有两种实现策略：
 * 栈策略（非公平模式）：后进先出（LIFO）的配对顺序
 * 队列策略（公平模式）：先进先出（FIFO）的配对顺序
 */
public class SynchronousQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue =  new SynchronousQueue<>();
        /*
        * 后进先出
        * */
        //BlockingQueue<Integer> queue2 =  new SynchronousQueue<>(true);

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                queue.put(1);
                System.out.println("Produced: " + 1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                System.out.println("Consumed: " + queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}
